﻿package com.gengine.utils
{
    import flash.utils.*;

    public class ArrayUtil extends Object
    {
        public static const MergeType_Plus:int = 1;
        public static const MergeType_Sub:int = 2;
        public static const MergeType_Replace:int = 3;

        public function ArrayUtil()
        {
            return;
        }// end function

        public static function removeItem(param1:Array, param2:Object) : Boolean
        {
            var _loc_3:* = param1.length;
            var _loc_4:int = 0;
            while (_loc_4 < _loc_3)
            {
                
                if (param1[_loc_4] == param2)
                {
                    param1.splice(_loc_4, 1);
                    return true;
                }
                _loc_4++;
            }
            return false;
        }// end function

        public static function removeArray(param1:Array, param2:Array) : void
        {
            var _loc_3:* = param2.length;
            var _loc_4:int = 0;
            while (_loc_4 < _loc_3)
            {
                
                removeItem(param1, param2[_loc_4]);
                _loc_4++;
            }
            return;
        }// end function

        public static function merge(param1:Array, param2:Array, param3, param4, param5:int = 0) : Array
        {
            var _loc_6:Array = null;
            var _loc_7:Object = null;
            var _loc_8:Object = null;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            if (!param1 || param1.length == 0)
            {
                _loc_6 = param2;
                for each (_loc_8 in _loc_6)
                {
                    
                    switch(param5)
                    {
                        case MergeType_Sub:
                        {
                            _loc_8[param4] = -_loc_8[param4];
                            break;
                        }
                        default:
                        {
                            break;
                        }
                    }
                }
                return _loc_6;
            }
            if (!param2 || param2.length == 0)
            {
                _loc_6 = param1;
                return _loc_6;
            }
            if (!param3)
            {
                _loc_6 = param1.concat(param2);
                return _loc_6;
            }
            var _loc_9:Array = [];
            var _loc_10:Array = [];
            if (!_loc_6)
            {
                _loc_6 = [];
            }
            var _loc_11:int = 0;
            while (_loc_11 < param1.length)
            {
                
                _loc_7 = param1[_loc_11];
                if (_loc_7.hasOwnProperty(param3))
                {
                    _loc_12 = 0;
                    while (_loc_12 < param2.length)
                    {
                        
                        _loc_8 = param2[_loc_12];
                        if (_loc_10.indexOf(_loc_12) == -1 && _loc_9.indexOf(_loc_12) == -1)
                        {
                            _loc_10.push(_loc_12);
                        }
                        if (_loc_8.hasOwnProperty(param3))
                        {
                            if (_loc_7[param3] == _loc_8[param3])
                            {
                                if (_loc_9.indexOf(_loc_12) == -1)
                                {
                                    _loc_9.push(_loc_12);
                                }
                                if (_loc_10.indexOf(_loc_12) != -1)
                                {
                                    _loc_10.splice(_loc_10.indexOf(_loc_12), 1);
                                }
                                switch(param5)
                                {
                                    case MergeType_Plus:
                                    {
                                        _loc_7[param4] = _loc_7[param4] + _loc_8[param4];
                                        break;
                                    }
                                    case MergeType_Sub:
                                    {
                                        _loc_7[param4] = _loc_7[param4] - _loc_8[param4];
                                        break;
                                    }
                                    case MergeType_Replace:
                                    {
                                        _loc_7[param4] = _loc_8[param4];
                                        break;
                                    }
                                    default:
                                    {
                                        break;
                                    }
                                }
                            }
                        }
                        _loc_12++;
                    }
                    _loc_6.push(_loc_7);
                }
                _loc_11++;
            }
            if (_loc_10.length > 0)
            {
                for each (_loc_13 in _loc_10)
                {
                    
                    _loc_8 = param2[_loc_13];
                    if (param5 == MergeType_Sub)
                    {
                        _loc_8[param4] = -_loc_8[param4];
                    }
                    _loc_6.push(_loc_8);
                }
            }
            return _loc_6;
        }// end function

        public static function soryNumberAry(param1:Array, param2:Boolean = true) : void
        {
            if (param2)
            {
                param1.sort(sortDesc);
            }
            else
            {
                param1.sort(sortAsc);
            }
            return;
        }// end function

        private static function sortDesc(param1:Number, param2:Number) : int
        {
            if (param1 > param2)
            {
                return -1;
            }
            if (param1 < param2)
            {
                return 1;
            }
            return 0;
        }// end function

        private static function sortAsc(param1:Number, param2:Number) : int
        {
            if (param1 > param2)
            {
                return 1;
            }
            if (param1 < param2)
            {
                return -1;
            }
            return 0;
        }// end function

        public static function cut(param1:Array, param2:Array) : Array
        {
            var _loc_4:* = undefined;
            var _loc_5:int = 0;
            var _loc_3:* = new Array();
            for each (_loc_4 in param1)
            {
                
                _loc_5 = param2.indexOf(_loc_4);
                if (_loc_5 == -1)
                {
                    _loc_3.push(_loc_4);
                }
            }
            return _loc_3;
        }// end function

        public static function add(param1:Array, param2:Array) : Array
        {
            var _loc_4:* = undefined;
            var _loc_5:int = 0;
            var _loc_3:* = new Array();
            for each (_loc_4 in param1)
            {
                
                _loc_3.push(_loc_4);
            }
            for each (_loc_4 in param2)
            {
                
                _loc_5 = _loc_3.indexOf(_loc_4);
                if (_loc_5 == -1)
                {
                    _loc_3.push(_loc_4);
                }
            }
            return _loc_3;
        }// end function

        public static function DictAsArr(param1:Dictionary) : Array
        {
            var _loc_3:* = undefined;
            var _loc_2:Array = [];
            for each (_loc_3 in param1)
            {
                
                _loc_2.push(_loc_3);
            }
            return _loc_2;
        }// end function

        public static function ArrtAsDic(param1:Array) : Dictionary
        {
            var _loc_3:* = undefined;
            var _loc_2:* = new Dictionary();
            for each (_loc_3 in param1)
            {
                
                _loc_2[_loc_3] = _loc_3;
            }
            return _loc_2;
        }// end function

    }
}
